package com.gzk.hrm.service.impl;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.gzk.hrm.constants.RedisConstants;
import com.gzk.hrm.domain.CourseType;
import com.gzk.hrm.mapper.CourseTypeMapper;
import com.gzk.hrm.service.ICourseTypeService;
import com.gzk.hrm.util.AssertUtils;
import com.gzk.hrm.vo.CrumbsVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * <p>
 * 课程目录 服务实现类
 * </p>
 *
 * @author jake.Chen
 * @since 2022-02-12
 */
@Service
@Slf4j
public class CourseTypeServiceImpl extends ServiceImpl<CourseTypeMapper, CourseType> implements ICourseTypeService {

    @Autowired
    private CourseTypeMapper courseTypeMapper;

    @Autowired
    private RedisTemplate<Object,Object> redisTemplate;

    @Override
    public boolean insert(CourseType entity) {
        //改数据库
        boolean insert = super.insert(entity);

        redisTemplate.delete(RedisConstants.COURSETYPE_TREEDATA);
        return insert;
    }

    @Override
    @CacheEvict(cacheNames = "COURSETYPE",key = "'TREEDATA'")
    public boolean deleteById(Serializable id) {
        //boolean b = super.deleteById(id);
        //redisTemplate.delete(RedisConstants.COURSETYPE_TREEDATA);
        return super.deleteById(id);
    }

    @Override
    public boolean updateById(CourseType entity) {
        boolean b = super.updateById(entity);
        redisTemplate.delete(RedisConstants.COURSETYPE_TREEDATA);
        return b;
    }

    @Override
    @Cacheable(cacheNames = "COURSETYPE",key = "'TREEDATA'")
    public List<CourseType> treeData() {

        /*List<CourseType> courseTypeTree = null;
        try {
            //先从redis里面查询有没有
            courseTypeTree = (List<CourseType>) redisTemplate.opsForValue().get(RedisConstants.COURSETYPE_TREEDATA);
            log.info("从redis中查询数据正常："+courseTypeTree);
        } catch (Exception e) {
            log.error("从redis中查询数据异常："+e.getMessage());
            e.printStackTrace();
        }

        //判断有没有值
        if(courseTypeTree != null){
            log.info("从redis中返回的数据："+courseTypeTree);
            //如果有直接返回
            return courseTypeTree;
        }

        //如果没有从数据库里面查
        List<CourseType> courseTypes = list2Tree();
        log.info("从DB中查询数据正常："+courseTypes);
        //设置redis
        redisTemplate.opsForValue().set(RedisConstants.COURSETYPE_TREEDATA, courseTypes);*/
        return list2Tree();

    }

    /**
     * 生成面包屑
     * @param courseTypeId
     */
    @Override
    public List<CrumbsVO> crumbs(Long courseTypeId) {
        AssertUtils.isNotNull(courseTypeId, "非法参数！");
        CourseType courseType = selectById(courseTypeId);
        AssertUtils.isNotNull(courseType, "参数不合法！！Pid不存在 ");
        //获取path
        String path = courseType.getPath();
        //分割
        String[] arrIds = path.split("\\.");

        //转换long类型的集合
        List<Long> courseTypeIds = Arrays.stream(arrIds).map(new Function<String, Long>() {
            @Override
            public Long apply(String s) {
                return Long.parseLong(s.trim());
            }
        }).collect(Collectors.toList());

        //批量查询
        List<CourseType> courseTypes = selectBatchIds(courseTypeIds);

        //创建VO对象集合
        List<CrumbsVO> crumbs = new ArrayList<>(courseTypes.size());
        //遍历查同级
        /*for (CourseType ownerCourseType : courseTypes) {
            //根据pid查询同级
            List<CourseType> otherCourseTypes = courseTypeMapper.selectByPid(ownerCourseType.getPid());
            //创建VO对象
            CrumbsVO crumbsVO = new CrumbsVO(ownerCourseType, otherCourseTypes);

            crumbs.add(crumbsVO);

        }*/
        //遍历查同级
        courseTypes.forEach(ownerCourseType-> {
            Wrapper<CourseType> wrapper = new EntityWrapper<>();
            wrapper.eq("pid", ownerCourseType.getPid()==null?0:ownerCourseType.getPid());
            List<CourseType> otherCourseTypes = selectList(wrapper);

            //删除自己
            otherCourseTypes.remove(ownerCourseType);


            //创建VO对象
            CrumbsVO crumbsVO = new CrumbsVO(ownerCourseType, otherCourseTypes);

            crumbs.add(crumbsVO);
                }
        );
        return crumbs;


    }


    /**
     * 从数据库里面查询tree
     * @return
     */
    public List<CourseType> list2Tree() {


        //方法一：子查询
        //return courseTypeMapper.selectCourseTypeTree(0L);

        //方法二：java代码封装
        //查询出所有的courseType
        List<CourseType> allCourseTypes = selectList(null);


        List<CourseType> firstCourseTypes = new ArrayList<>();
        //遍历查询出第一级的课程类型
        allCourseTypes.forEach(courseType ->{
            if(courseType.getPid().longValue() == 0){
                //如果是第一层
                firstCourseTypes.add(courseType);
            }else {
                //如果非第一层
                for (CourseType allCourseType : allCourseTypes) {
                    if(courseType.getPid().longValue() == allCourseType.getId().longValue()){
                        allCourseType.getChildren().add(courseType);
                        break;
                    }
                }
            }
        });
        return firstCourseTypes;
    }
}
